#include <iostream>
#include <unistd.h>
#include <string>
#include <functional>
#include <vector>
#include <time.h>
#include <stdio.h>
#include <pthread.h>

// void *ThreadRountine(void *args){
//     std::string thread1 = (const char*)args;
//     while(true){
//         std::cout<<"new thread"<<std::endl;
//         sleep(1);
//     }
// }

// int main(){
//     pthread_t tid;
//     pthread_create(&tid,nullptr,ThreadRountine,(void*)"thread1");
//     while(true){
//         std::cout << "main thread" << std::endl;
//         sleep(1);
//     }
//     return 0;
// }
// using fun_t = std::function<void()>;
// class ThreadDate
// {
// public:
//     ThreadDate(const std::string &name, const uint64_t &time,
//                fun_t f) : threadname(name), createtime(time), fun(f) {}

// public:
//     std::string threadname;
//     uint64_t createtime;
//     fun_t fun;
// };
// void *ThreadRountine(void *args)
// {
//     int a = 10;
//     ThreadDate *td = static_cast<ThreadDate*>(args);
//     while (true)
//     {
//         std::cout <<"new thread"<<"  thread name"<<td->threadname<<" create time"<< td->createtime<< std::endl;
//         td->fun();
//         sleep(1);
//     }
// }
// void Print(){
//     std::cout << "我是线程的一部分" << std::endl;
// }
// int main()
// {
//     std::vector<pthread_t> Pthread;
//     for(int i = 0;i < 5;i++){
//         char threadname[64];
//         snprintf(threadname,sizeof(threadname),"%s-%lu","thread",i);
//         pthread_t tid;
//         ThreadDate *td = new ThreadDate(threadname, (uint64_t)time(nullptr), Print);
//         pthread_create(&tid, nullptr, ThreadRountine, td);
//         Pthread.push_back(tid);
//         sleep(1);
//     }

//     while (true)
//     {
//         std::cout << "main thread" << std::endl;
//         sleep(1);
//     }
//     return 0;
// }

// std::string tohax(pthread_t tid){
//     char id[64];
//     snprintf(id, sizeof(id),"0x%lx",tid);
//     return id;
// }
// class thread_return{
// public:thread_rerurn(pthread_t id;const std::string &info;int code)
//     :id_(id),
//     info_(info),
//     code_(code)
//     {}
// pthread_t id_;
// std::string info_;
// int code_;
// };
// void *ThreadRountine(void *arg){
//     usleep(1000);
//     std:: string name = static_cast<const char*>(arg);
//     int n = 5;
//     while (n--)
//     {
//         std::cout << "new thread"<< " thread name:" << name<< " thread id:" <<tohax(pthread_self()) << std::endl;
//         sleep(1);
//     }
//     //exit(14); 进程终止
//     //return nullptr;线程终止
//     //pthread_exit(nullptr);//终止线程
//     return (void*) "thread done"//返回的是字符串常量的起始地址
// }
// int main()
// {
//     pthread_t tid;
//     pthread_create(&tid,nullptr,ThreadRountine,(void*)"thread1");
//     while(true){
//         std::cout << "main thread" << "  main thread id:"<< tohax(pthread_self()) << std::endl;
//         sleep(1);
//     }
//     //获取线程id
//     //pthread_self()

//     //线程默认要等待
//     //1.线程退出，没有等待，会导致类似于进程中的僵尸问题
//     //2.线程退出时，主线程如何获取新线程的返回值（pthread_join(tid，void** retval)）
//     //retval：是一个输出型参数 ，如果我们要得到新线程的返回值，我们得到的也应该是void*
//         //为了得到void* 需要传入一个void**

//     //线程等待
//     int n = pthread_join(tid,nullptr);
//     std::cout <<"main thread done" <<n << std::endl;
//     return 0;
// }

void *ThreadRountine(void *arg)
{
    // pthread_detach(pthread_self());线程分离
    std::string name = static_cast<const char *>(arg);

    int n = 5;
    while (true)
    {
        std::cout << "new thread" << std::endl;
        sleep(1);
    }
}
int main()
{
    pthread_t tid;
    pthread_create(&tid, nullptr, ThreadRountine, (void *)"thread-1");
    // pthread_detach(tid);//让新线程分离
    //  线程是可以设置为分离状态的
    //  线程模式joinable的
    //  pthread_detach(tid)线程分离

    // 线程取消
    // 一个线程被分离的，是可以被取消，但不能被等待
    int i = pthread_cancel(tid);
    std::cout << " main thread cancel done: " << i << std::endl;

    // 线程等待
    void *ret = nullptr;
    int n = pthread_join(tid, &ret);
    std::cout << " main thread done: " << n << "  threrad return" << (long long)ret << std::endl;
    return 0;
}